package Class;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 姚东名
 * Date: 2024-05-16
 * Time: 20:45
 */
class Student {
    //字段 属性 成员变量：定义在类当中，方法的外面
    //private的关键字的作用是：为了封装类
    //private 可以修饰 成员变量 和 成员方法
    public String name;//名字
    private int age;//年龄
    private String strNum;//学号
    //static关键字：静态
    //用static关键字修饰的成员变量叫静态的成员变量，也叫类变量。
    //无论是 student1 还是 student2 都是在同一班，就使用static修饰成员变量 放在方法区中 ->不依赖对象(也就是说，不需要 对象的实例化)
    public static String className;//班级
    //从语言上来讲，对类进行封装，把细节隐藏起来。提供你公开的内容即可

    //构造方法：带参数与 不带参数
    //构造方法的目的是：对 对象初始化（在对象的实例化的时候，初始化了）
    public Student(String name, int age, String strNum) {
        this.name = name;
        this.age = age;
        this.strNum = strNum;
        System.out.println("这是带三个参数的构造方法……");
    }

    public Student() {
        System.out.println("这是不带参数的构造方法……");
    }

    //成员方法
    public void eat() {
        func();
        System.out.println(this.name+"正在吃饭……");
    }
    public void doClass() {
        System.out.println(this.name+"正在上课……");
    }
    private void func() {
        //其他业务操作：
        System.out.println("这个方法就是为本类其他访问服务的，不对外公开");
    }
    public void show() {
        System.out.println("姓名："+this.name+" 年龄："+this.age+" 学号："+strNum+" 班级："+className);
    }
    //提供一些接口，供你使用：
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getStrNum() {
        return strNum;
    }

    public void setStrNum(String strNum) {
        this.strNum = strNum;
    }
}
public class Test0516 {
    public static int count = 10;//类成员 -> 用static关键字修饰 （属于类的，不属于对象的）
    public static void main(String[] args) {
        //四不像：
        Test0516 Test0516a = new Test0516();
        Test0516a.count++;//11

        Test0516 Test0516b = new Test0516();
        Test0516b.count++;//12

        Test0516 Test0516c = new Test0516();
        Test0516c.count--;//11

        Test0516.count++;//12 -> 在方法区中

        System.out.println(count);//12
    }
    public static void main5(String[] args) {
        /*Student student1 = new Student();
        Student.className = "2班";
        System.out.println(student1.className);*/
        //哪个好？通过对象的引用访问 ： 通过类名访问:(类名.方法名)
        /*
        前提：静态的成员变量，也叫做类变量。也就说 -> 虽然都是可以访问的，但是建议 通过类名访问。
        有一句话记住：静态的 不依赖对象。意味着 不需要对象的引用 来访问。(根本不需要实例化对象)
        */
        //通过类名访问:
        Student student1 = null;
        Student.className = "2班";
        System.out.println(Student.className);
        //通过对象的引用访问:
        System.out.println(student1.name);//java.lang.NullPointerException（空指针异常）
    }
    public static void main4(String[] args) {
        Student student1 = new Student("张三", 10, "19865095509");
        //通过对象的引用访问;
        student1.className = "1班";
        //通过类名访问:(类名.方法名)
        Student.className = "1班";
        //调用成员方法：
        student1.show();
        System.out.println("============================");
        Student student2 = new Student("李四", 15, "13531039621");
        //通过对象的引用访问;
        student2.className = "1班";
        //通过类名访问:(类名.方法名)
        Student.className = "1班";
        //调用成员方法：
        student2.show();

    }
    public static void main3(String[] args) {
        Student student1 = new Student();
        //虽然成员变量被private关键字修饰，可以通过接口来对成员变量进行赋值
        student1.setName("张三");
        System.out.println(student1.getName());
        student1.setAge(10);
        System.out.println(student1.getAge());
        student1.setStrNum("19865095509");
        System.out.println(student1.getStrNum());

        Student student2 = new Student();
        student2.setName("李四");
        System.out.println(student2.getName());
        student2.setAge(15);
        System.out.println(student2.getAge());
        student2.setStrNum("13531039621");
        System.out.println(student2.getStrNum());
    }
    public static void main2(String[] args) {
        Student student1 = new Student("张三", 10, "19865095509");
        //调用成员方法：
        student1.eat();
        student1.doClass();
        System.out.println("===============");
        Student student2 = new Student("李四", 15, "13531039621");
        //调用成员方法：
        student2.eat();
        student2.doClass();
        //注意：这两个对象在不同的内存中
    }
    public static void main1(String[] args) {
        //对象的实例化1：关键的两步：1.给对象申请空间 2.调用合适的构造方法
        /*Student student1 = new Student();
        student1.name = "张三";
        student1.age = 10;
        student1.strNum = "19865095509";
        System.out.println(student1.name);
        System.out.println(student1.age);
        System.out.println(student1.strNum);
        //调用成员方法：
        student1.eat();
        student1.doClass();

        //对象的实例化2
        Student student2 = new Student();
        student2.name = "李四";
        student2.age = 18;
        student2.strNum = "13531039621";
        System.out.println("===============");
        System.out.println(student2.name);
        System.out.println(student2.age);
        System.out.println(student2.strNum);
        student2.eat();
        student2.doClass();*/
    }
}
